home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / Development Tools & Languages / • Other Platforms / PCCTS / antlr / antlr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-14  |  37.3 KB  |  1,782 lines  |  [TEXT/MPS ]
  1. /*
  2.  * A n t l r  T r a n s l a t i o n  H e a d e r
  3.  *
  4.  * Terence Parr, Will Cohen, and Hank Dietz: 1989-1994
  5.  * Purdue University Electrical Engineering
  6.  * With AHPCRC, University of Minnesota
  7.  * ANTLR Version 1.23b1
  8.  */
  9. #include <stdio.h>
  10. #define ANTLR_VERSION    123b1
  11.  
  12. #ifdef __cplusplus
  13. #ifndef __STDC__
  14. #define __STDC__
  15. #endif
  16. #endif
  17. #include "set.h"
  18. #include <ctype.h>
  19. #include "syn.h"
  20. #include "hash.h"
  21. #include "generic.h"
  22. #define zzcr_attr(attr,tok,t)
  23. #define zzEOF_TOKEN 1
  24. #define zzSET_SIZE 20
  25. #include "antlr.h"
  26. #include "tokens.h"
  27. #include "dlgdef.h"
  28. #include "mode.h"
  29. ANTLR_INFO
  30.  
  31. #ifdef __STDC__
  32. static void chkToken(char *, char *, char *, int);
  33. #else
  34. static void chkToken();
  35. #endif
  36.  
  37. static int class_nest_level = 0;
  38.  
  39. void
  40. #ifdef __STDC__
  41. grammar(void)
  42. #else
  43. grammar()
  44. #endif
  45. {
  46.     zzRULE;
  47.     zzBLOCK(zztasp1);
  48.     zzMake0;
  49.     {
  50.     Graph g;  
  51.     {
  52.         zzBLOCK(zztasp2);
  53.         zzMake0;
  54.         {
  55.         while ( 1 ) {
  56.             if ( (LA(1)==83) ) {
  57.                 zzmatch(83); zzCONSUME;
  58.                 zzmatch(Action);
  59.                 
  60.                 if ( HdrAction==NULL ) {
  61.                     HdrAction = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  62.                     require(HdrAction!=NULL, "rule grammar: cannot allocate header action");
  63.                     strcpy(HdrAction, LATEXT(1));
  64.                 }
  65.                 else warn("additional #header statement ignored");
  66.  zzCONSUME;
  67.             }
  68.             else {
  69.                 if ( (LA(1)==84) ) {
  70.                     zzmatch(84); zzCONSUME;
  71.                     zzmatch(QuotedTerm);
  72.                     
  73.                     if ( GenCC ) {
  74.                         warn("#parser meta-op incompatible with -CC; ignored");
  75.                     }
  76.                     else {
  77.                         if ( strcmp(ParserName,"zzparser")==0 ) {
  78.                             ParserName=StripQuotes(mystrdup(LATEXT(1)));
  79.                             if ( RulePrefix[0]!='\0' )
  80.                             {
  81.                                 warn("#parser meta-op incompatible with '-gp prefix'; '-gp' ignored");
  82.                                 RulePrefix[0]='\0';
  83.                             }
  84.                         }
  85.                         else warn("additional #parser statement ignored");
  86.                     }
  87.  zzCONSUME;
  88.                 }
  89.                 else {
  90.                     if ( (LA(1)==85) ) {
  91.                         zzmatch(85); zzCONSUME;
  92.                         zzmatch(QuotedTerm);
  93.                         {
  94.                             char *fname;
  95.                             zzantlr_state st; FILE *f; struct zzdlg_state dst;
  96.                             UserTokenDefsFile = mystrdup(LATEXT(1));
  97.                             zzsave_antlr_state(&st);
  98.                             zzsave_dlg_state(&dst);
  99.                             fname = mystrdup(LATEXT(1));
  100.                             f = fopen(StripQuotes(fname), "r");
  101.                             if ( f==NULL ) {warn(eMsg1("cannot open token defs file '%s'", fname+1));}
  102.                             else {
  103.                                 ANTLRm(enum_file(fname+1), f, PARSE_ENUM_FILE);
  104.                                 UserDefdTokens = 1;
  105.                             }
  106.                             zzrestore_antlr_state(&st);
  107.                             zzrestore_dlg_state(&dst);
  108.                         }  
  109.  zzCONSUME;
  110.                     }
  111.                     else break;
  112.                 }
  113.             }
  114.             zzLOOP(zztasp2);
  115.         }
  116.         zzEXIT(zztasp2);
  117.         }
  118.     }
  119.     {
  120.         zzBLOCK(zztasp2);
  121.         zzMake0;
  122.         {
  123.         while ( 1 ) {
  124.             if ( (LA(1)==Action) ) {
  125.                 zzmatch(Action);
  126.                 {
  127.                     UserAction *ua = newUserAction(LATEXT(1));
  128.                     ua->file = action_file; ua->line = action_line;
  129.                     if ( class_nest_level>0 ) list_add(&class_actions, ua);
  130.                     else list_add(&BeforeActions, ua);
  131.                 }  
  132.  zzCONSUME;
  133.             }
  134.             else {
  135.                 if ( (LA(1)==96) ) {
  136.                     laction();
  137.                 }
  138.                 else {
  139.                     if ( (LA(1)==97) ) {
  140.                         aLexclass();
  141.                     }
  142.                     else {
  143.                         if ( (LA(1)==100) ) {
  144.                             token();
  145.                         }
  146.                         else {
  147.                             if ( (LA(1)==98) ) {
  148.                                 error();
  149.                             }
  150.                             else {
  151.                                 if ( (LA(1)==99) ) {
  152.                                     tclass();
  153.                                 }
  154.                                 else {
  155.                                     if ( (LA(1)==87) ) {
  156.                                         class_def();
  157.                                     }
  158.                                     else {
  159.                                         if ( (LA(1)==86) ) {
  160.                                             zzmatch(86);
  161.                                             
  162.                                             if ( class_nest_level==0 )
  163.                                             warn("missing class definition for trailing '}'");
  164.                                             class_nest_level--;
  165.  zzCONSUME;
  166.                                         }
  167.                                         else break;
  168.                                     }
  169.                                 }
  170.                             }
  171.                         }
  172.                     }
  173.                 }
  174.             }
  175.             zzLOOP(zztasp2);
  176.         }
  177.         zzEXIT(zztasp2);
  178.         }
  179.     }
  180.     rule();
  181.     g=zzaArg(zztasp1,3); SynDiag = (Junction *) zzaArg(zztasp1,3 ).left;  
  182.     {
  183.         zzBLOCK(zztasp2);
  184.         zzMake0;
  185.         {
  186.         while ( 1 ) {
  187.             if ( (LA(1)==NonTerminal) ) {
  188.                 rule();
  189.                 if ( zzaArg(zztasp2,1 ).left!=NULL ) {g.right = NULL; g = Or(g, zzaArg(zztasp2,1));}  
  190.             }
  191.             else {
  192.                 if ( (LA(1)==97) ) {
  193.                     aLexclass();
  194.                 }
  195.                 else {
  196.                     if ( (LA(1)==100) ) {
  197.                         token();
  198.                     }
  199.                     else {
  200.                         if ( (LA(1)==98) ) {
  201.                             error();
  202.                         }
  203.                         else {
  204.                             if ( (LA(1)==99) ) {
  205.                                 tclass();
  206.                             }
  207.                             else {
  208.                                 if ( (LA(1)==87) ) {
  209.                                     class_def();
  210.                                 }
  211.                                 else {
  212.                                     if ( (LA(1)==86) ) {
  213.                                         zzmatch(86);
  214.                                         
  215.                                         if ( class_nest_level==0 )
  216.                                         warn("missing class definition for trailing '}'");
  217.                                         class_nest_level--;
  218.  zzCONSUME;
  219.                                     }
  220.                                     else break;
  221.                                 }
  222.                             }
  223.                         }
  224.                     }
  225.                 }
  226.             }
  227.             zzLOOP(zztasp2);
  228.         }
  229.         zzEXIT(zztasp2);
  230.         }
  231.     }
  232.     {
  233.         zzBLOCK(zztasp2);
  234.         zzMake0;
  235.         {
  236.         while ( 1 ) {
  237.             if ( (LA(1)==Action) ) {
  238.                 zzmatch(Action);
  239.                 {
  240.                     UserAction *ua = newUserAction(LATEXT(1));
  241.                     ua->file = action_file; ua->line = action_line;
  242.                     if ( class_nest_level>0 ) list_add(&class_actions, ua);
  243.                     else list_add(&AfterActions, ua);
  244.                 }  
  245.  zzCONSUME;
  246.             }
  247.             else {
  248.                 if ( (LA(1)==96) ) {
  249.                     laction();
  250.                 }
  251.                 else {
  252.                     if ( (LA(1)==98) ) {
  253.                         error();
  254.                     }
  255.                     else {
  256.                         if ( (LA(1)==99) ) {
  257.                             tclass();
  258.                         }
  259.                         else {
  260.                             if ( (LA(1)==87) ) {
  261.                                 class_def();
  262.                             }
  263.                             else {
  264.                                 if ( (LA(1)==86) ) {
  265.                                     zzmatch(86);
  266.                                     
  267.                                     if ( class_nest_level==0 )
  268.                                     warn("missing class definition for trailing '}'");
  269.                                     class_nest_level--;
  270.  zzCONSUME;
  271.                                 }
  272.                                 else break;
  273.                             }
  274.                         }
  275.                     }
  276.                 }
  277.             }
  278.             zzLOOP(zztasp2);
  279.         }
  280.         zzEXIT(zztasp2);
  281.         }
  282.     }
  283.     zzmatch(Eof); zzCONSUME;
  284.     zzEXIT(zztasp1);
  285.     return;
  286. fail:
  287.     zzEXIT(zztasp1);
  288.     CannotContinue=TRUE;  
  289.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  290.     zzresynch(setwd1, 0x1);
  291.     }
  292. }
  293.  
  294. void
  295. #ifdef __STDC__
  296. class_def(void)
  297. #else
  298. class_def()
  299. #endif
  300. {
  301.     zzRULE;
  302.     zzBLOCK(zztasp1);
  303.     zzMake0;
  304.     {
  305.     int go=1; char name[MaxRuleName+1];  
  306.     zzmatch(87); zzCONSUME;
  307.     {
  308.         zzBLOCK(zztasp2);
  309.         zzMake0;
  310.         {
  311.         if ( (LA(1)==NonTerminal) ) {
  312.             zzmatch(NonTerminal);
  313.             if(go) strncpy(name,LATEXT(1),MaxRuleName);  
  314.  zzCONSUME;
  315.         }
  316.         else {
  317.             if ( (LA(1)==TokenTerm) ) {
  318.                 zzmatch(TokenTerm);
  319.                 if(go) strncpy(name,LATEXT(1),MaxRuleName);  
  320.  zzCONSUME;
  321.             }
  322.             else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  323.         }
  324.         zzEXIT(zztasp2);
  325.         }
  326.     }
  327.     
  328.     if ( CurrentClassName[0]!='\0' && strcmp(CurrentClassName,name)!=0
  329.     && GenCC ) {
  330.         err("only one grammar class allowed in this release");
  331.         go = 0;
  332.     }
  333.     else strcpy(CurrentClassName, name);
  334.     if ( !GenCC ) { err("class meta-op used without C++ option"); }  
  335.     zzmatch(90);
  336.     
  337.     no_classes_found = 0;
  338.     if ( class_nest_level>=1 ) {warn("cannot have nested classes");}
  339.     else class_nest_level++;
  340.  zzCONSUME;
  341.     zzEXIT(zztasp1);
  342.     return;
  343. fail:
  344.     zzEXIT(zztasp1);
  345.     CannotContinue=TRUE;  
  346.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  347.     zzresynch(setwd1, 0x2);
  348.     }
  349. }
  350.  
  351. void
  352. #ifdef __STDC__
  353. rule(void)
  354. #else
  355. rule()
  356. #endif
  357. {
  358.     zzRULE;
  359.     zzBLOCK(zztasp1);
  360.     zzMake0;
  361.     {
  362.     
  363.     RuleEntry *q; Junction *p; Graph r; int f, l; ECnode *e;
  364.     set toksrefd, rulesrefd;
  365.     char *pdecl=NULL, *ret=NULL, *a; CurRetDef = CurParmDef = NULL;
  366.     zzmatch(NonTerminal);
  367.     q=NULL;
  368.     if ( hash_get(Rname, LATEXT(1))!=NULL ) {
  369.         warn(eMsg1("duplicate rule definition: '%s'",LATEXT(1)));
  370.         CannotContinue=TRUE;
  371.     }
  372.     else
  373.     {
  374.         q = (RuleEntry *)hash_add(Rname,
  375.         LATEXT(1),
  376.         (Entry *)newRuleEntry(LATEXT(1)));
  377.         CurRule = q->str;
  378.     }
  379.     CurRuleNode = q;
  380.     f = CurFile; l = zzline;
  381.     NumRules++;
  382.  zzCONSUME;
  383.     {
  384.         zzBLOCK(zztasp2);
  385.         zzMake0;
  386.         {
  387.         if ( (LA(1)==91) ) {
  388.             zzmatch(91);
  389.             if ( q!=NULL ) q->noAST = TRUE;  
  390.  zzCONSUME;
  391.         }
  392.         zzEXIT(zztasp2);
  393.         }
  394.     }
  395.     {
  396.         zzBLOCK(zztasp2);
  397.         zzMake0;
  398.         {
  399.         ;  
  400.         if ( (setwd1[LA(1)]&0x4) ) {
  401.             {
  402.                 zzBLOCK(zztasp3);
  403.                 zzMake0;
  404.                 {
  405.                 if ( (LA(1)==92) ) {
  406.                     zzmatch(92); zzCONSUME;
  407.                 }
  408.                 zzEXIT(zztasp3);
  409.                 }
  410.             }
  411.             zzmatch(PassAction);
  412.             pdecl = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  413.             require(pdecl!=NULL, "rule rule: cannot allocate param decl");
  414.             strcpy(pdecl, LATEXT(1));
  415.             CurParmDef = pdecl;
  416.  zzCONSUME;
  417.         }
  418.         zzEXIT(zztasp2);
  419.         }
  420.     }
  421.     {
  422.         zzBLOCK(zztasp2);
  423.         zzMake0;
  424.         {
  425.         if ( (LA(1)==93) ) {
  426.             zzmatch(93); zzCONSUME;
  427.             zzmatch(PassAction);
  428.             ret = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  429.             require(ret!=NULL, "rule rule: cannot allocate ret type");
  430.             strcpy(ret, LATEXT(1));
  431.             CurRetDef = ret;
  432.  zzCONSUME;
  433.         }
  434.         zzEXIT(zztasp2);
  435.         }
  436.     }
  437.     {
  438.         zzBLOCK(zztasp2);
  439.         zzMake0;
  440.         {
  441.         if ( (LA(1)==QuotedTerm) ) {
  442.             zzmatch(QuotedTerm);
  443.             if ( q!=NULL ) q->egroup=mystrdup(LATEXT(1));  
  444.  zzCONSUME;
  445.         }
  446.         zzEXIT(zztasp2);
  447.         }
  448.     }
  449.     
  450.     if ( GenEClasseForRules && q!=NULL ) {
  451.         e = newECnode;
  452.         require(e!=NULL, "cannot allocate error class node");
  453.         if ( q->egroup == NULL ) {a = q->str; a[0] = (char)toupper(a[0]);}
  454.         else a = q->egroup;
  455.         if ( Tnum( a ) == 0 )
  456.         {
  457.             e->tok = addTname( a );
  458.             list_add(&eclasses, (char *)e);
  459.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  460.             /* refers to itself */
  461.             list_add(&(e->elist), mystrdup(q->str));
  462.         }
  463.         else {
  464.             warn(eMsg1("default errclass for '%s' would conflict with token/errclass/tokclass",a));
  465.             if ( q->egroup == NULL ) a[0] = (char)tolower(a[0]);
  466.             free((char *)e);
  467.         }
  468.     }
  469.     BlkLevel++;  
  470.     zzmatch(94); zzCONSUME;
  471.     block( &toksrefd, &rulesrefd );
  472.     r = makeBlk(zzaArg(zztasp1,7),0);
  473.     ((Junction *)r.left)->jtype = RuleBlk;
  474.     if ( q!=NULL ) ((Junction *)r.left)->rname = q->str;
  475.     ((Junction *)r.left)->file = f;
  476.     ((Junction *)r.left)->line = l;
  477.     ((Junction *)r.left)->pdecl = pdecl;
  478.     ((Junction *)r.left)->ret = ret;
  479.     ((Junction *)r.left)->lock = makelocks();
  480.     ((Junction *)r.left)->pred_lock = makelocks();
  481.     ((Junction *)r.left)->tokrefs = toksrefd;
  482.     ((Junction *)r.left)->rulerefs = rulesrefd;
  483.     p = newJunction();    /* add EndRule Node */
  484.     ((Junction *)r.right)->p1 = (Node *)p;
  485.     r.right = (Node *) p;
  486.     p->jtype = EndRule;
  487.     p->lock = makelocks();
  488.     p->pred_lock = makelocks();
  489.     ((Junction *)r.left)->end = p;
  490.     if ( q!=NULL ) q->rulenum = NumRules;
  491.     zzaArg(zztasp1,7) = r;
  492.     --BlkLevel;  
  493.     zzmatch(95); zzCONSUME;
  494.     {
  495.         zzBLOCK(zztasp2);
  496.         zzMake0;
  497.         {
  498.         if ( (LA(1)==Action) ) {
  499.             zzmatch(Action);
  500.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  501.             require(a!=NULL, "rule rule: cannot allocate error action");
  502.             strcpy(a, LATEXT(1));
  503.             ((Junction *)r.left)->erraction = a;
  504.  zzCONSUME;
  505.         }
  506.         zzEXIT(zztasp2);
  507.         }
  508.     }
  509.     if ( q==NULL ) zzaArg(zztasp1,0 ).left = NULL; else zzaArg(zztasp1,0) = zzaArg(zztasp1,7);  
  510.     CurRuleNode = NULL;  
  511.     zzEXIT(zztasp1);
  512.     return;
  513. fail:
  514.     zzEXIT(zztasp1);
  515.     CannotContinue=TRUE;  
  516.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  517.     zzresynch(setwd1, 0x8);
  518.     }
  519. }
  520.  
  521. void
  522. #ifdef __STDC__
  523. laction(void)
  524. #else
  525. laction()
  526. #endif
  527. {
  528.     zzRULE;
  529.     zzBLOCK(zztasp1);
  530.     zzMake0;
  531.     {
  532.     char *a;  
  533.     zzmatch(96); zzCONSUME;
  534.     zzmatch(Action);
  535.     
  536.     a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  537.     require(a!=NULL, "rule laction: cannot allocate action");
  538.     strcpy(a, LATEXT(1));
  539.     list_add(&LexActions, a);
  540.  zzCONSUME;
  541.     zzEXIT(zztasp1);
  542.     return;
  543. fail:
  544.     zzEXIT(zztasp1);
  545.     CannotContinue=TRUE;  
  546.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  547.     zzresynch(setwd1, 0x10);
  548.     }
  549. }
  550.  
  551. void
  552. #ifdef __STDC__
  553. aLexclass(void)
  554. #else
  555. aLexclass()
  556. #endif
  557. {
  558.     zzRULE;
  559.     zzBLOCK(zztasp1);
  560.     zzMake0;
  561.     {
  562.     zzmatch(97); zzCONSUME;
  563.     zzmatch(TokenTerm);
  564.     lexclass(mystrdup(LATEXT(1)));  
  565.  zzCONSUME;
  566.     zzEXIT(zztasp1);
  567.     return;
  568. fail:
  569.     zzEXIT(zztasp1);
  570.     CannotContinue=TRUE;  
  571.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  572.     zzresynch(setwd1, 0x20);
  573.     }
  574. }
  575.  
  576. void
  577. #ifdef __STDC__
  578. error(void)
  579. #else
  580. error()
  581. #endif
  582. {
  583.     zzRULE;
  584.     zzBLOCK(zztasp1);
  585.     zzMake0;
  586.     {
  587.     char *t=NULL; ECnode *e; int go=1; TermEntry *p;  
  588.     zzmatch(98); zzCONSUME;
  589.     {
  590.         zzBLOCK(zztasp2);
  591.         zzMake0;
  592.         {
  593.         ;  
  594.         if ( (LA(1)==TokenTerm) ) {
  595.             zzmatch(TokenTerm);
  596.             t=mystrdup(LATEXT(1));  
  597.  zzCONSUME;
  598.         }
  599.         else {
  600.             if ( (LA(1)==QuotedTerm) ) {
  601.                 zzmatch(QuotedTerm);
  602.                 t=mystrdup(LATEXT(1));  
  603.  zzCONSUME;
  604.             }
  605.             else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  606.         }
  607.         zzEXIT(zztasp2);
  608.         }
  609.     }
  610.     e = newECnode;
  611.     require(e!=NULL, "cannot allocate error class node");
  612.     e->lexclass = CurrentLexClass;
  613.     if ( Tnum( (t=StripQuotes(t)) ) == 0 )
  614.     {
  615.         if ( hash_get(Texpr, t) != NULL )
  616.         warn(eMsg1("errclass name conflicts with regular expression  '%s'",t));
  617.         e->tok = addTname( t );
  618.         set_orel(e->tok, &imag_tokens);
  619.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  620.         "hash table mechanism is broken");
  621.         p->classname = 1;    /* entry is errclass name, not token */
  622.         list_add(&eclasses, (char *)e);
  623.     }
  624.     else
  625.     {
  626.     warn(eMsg1("redefinition of errclass or conflict w/token or tokclass '%s'; ignored",t));
  627.     free( (char *)e );
  628.     go=0;
  629. }
  630.     zzmatch(90); zzCONSUME;
  631.     {
  632.         zzBLOCK(zztasp2);
  633.         zzMake0;
  634.         {
  635.         if ( (LA(1)==NonTerminal) ) {
  636.             zzmatch(NonTerminal);
  637.             if ( go ) t=mystrdup(LATEXT(1));  
  638.  zzCONSUME;
  639.         }
  640.         else {
  641.             if ( (LA(1)==TokenTerm) ) {
  642.                 zzmatch(TokenTerm);
  643.                 if ( go ) t=mystrdup(LATEXT(1));  
  644.  zzCONSUME;
  645.             }
  646.             else {
  647.                 if ( (LA(1)==QuotedTerm) ) {
  648.                     zzmatch(QuotedTerm);
  649.                     if ( go ) t=mystrdup(LATEXT(1));  
  650.  zzCONSUME;
  651.                 }
  652.                 else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  653.             }
  654.         }
  655.         zzEXIT(zztasp2);
  656.         }
  657.     }
  658.     if ( go ) list_add(&(e->elist), t);  
  659.     {
  660.         zzBLOCK(zztasp2);
  661.         zzMake0;
  662.         {
  663.         while ( (setwd1[LA(1)]&0x40) ) {
  664.             {
  665.                 zzBLOCK(zztasp3);
  666.                 zzMake0;
  667.                 {
  668.                 if ( (LA(1)==NonTerminal) ) {
  669.                     zzmatch(NonTerminal);
  670.                     if ( go ) t=mystrdup(LATEXT(1));  
  671.  zzCONSUME;
  672.                 }
  673.                 else {
  674.                     if ( (LA(1)==TokenTerm) ) {
  675.                         zzmatch(TokenTerm);
  676.                         if ( go ) t=mystrdup(LATEXT(1));  
  677.  zzCONSUME;
  678.                     }
  679.                     else {
  680.                         if ( (LA(1)==QuotedTerm) ) {
  681.                             zzmatch(QuotedTerm);
  682.                             if ( go ) t=mystrdup(LATEXT(1));  
  683.  zzCONSUME;
  684.                         }
  685.                         else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  686.                     }
  687.                 }
  688.                 zzEXIT(zztasp3);
  689.                 }
  690.             }
  691.             if ( go ) list_add(&(e->elist), t);  
  692.             zzLOOP(zztasp2);
  693.         }
  694.         zzEXIT(zztasp2);
  695.         }
  696.     }
  697.     zzmatch(86); zzCONSUME;
  698.     zzEXIT(zztasp1);
  699.     return;
  700. fail:
  701.     zzEXIT(zztasp1);
  702.     CannotContinue=TRUE;  
  703.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  704.     zzresynch(setwd1, 0x80);
  705.     }
  706. }
  707.  
  708. void
  709. #ifdef __STDC__
  710. tclass(void)
  711. #else
  712. tclass()
  713. #endif
  714. {
  715.     zzRULE;
  716.     zzBLOCK(zztasp1);
  717.     zzMake0;
  718.     {
  719.     char *t=NULL; TCnode *e; int go=1,tok; TermEntry *p, *term;  
  720.     zzmatch(99); zzCONSUME;
  721.     zzmatch(TokenTerm);
  722.     t=mystrdup(LATEXT(1));  
  723.  zzCONSUME;
  724.     e = newTCnode;
  725.     require(e!=NULL, "cannot allocate token class node");
  726.     e->lexclass = CurrentLexClass;
  727.     if ( Tnum( t ) == 0 )
  728.     {
  729.         e->tok = addTname( t );
  730.         set_orel(e->tok, &imag_tokens);
  731.         require((p=(TermEntry *)hash_get(Tname, t)) != NULL,
  732.         "hash table mechanism is broken");
  733.         p->classname = 1;    /* entry is class name, not token */
  734.         p->tclass = e;        /* save ptr to this tclass def */
  735.         list_add(&tclasses, (char *)e);
  736.     }
  737.     else
  738.     {
  739.     warn(eMsg1("redefinition of tokclass or conflict w/token '%s'; ignored",t));
  740.     free( (char *)e );
  741.     go=0;
  742. }
  743.     zzmatch(90); zzCONSUME;
  744.     {
  745.         zzBLOCK(zztasp2);
  746.         zzMake0;
  747.         {
  748.         while ( (setwd2[LA(1)]&0x1) ) {
  749.             {
  750.                 zzBLOCK(zztasp3);
  751.                 zzMake0;
  752.                 {
  753.                 if ( (LA(1)==TokenTerm) ) {
  754.                     zzmatch(TokenTerm);
  755.                     if ( go ) {
  756.                         term = (TermEntry *) hash_get(Tname, LATEXT(1));
  757.                         if ( term==NULL && UserDefdTokens ) {
  758.                             err("implicit token definition not allowed with #tokdefs");
  759.                             go = 0;
  760.                         }
  761.                         else {t=mystrdup(LATEXT(1)); tok=addTname(LATEXT(1));}
  762.                     }  
  763.  zzCONSUME;
  764.                 }
  765.                 else {
  766.                     if ( (LA(1)==QuotedTerm) ) {
  767.                         zzmatch(QuotedTerm);
  768.                         if ( go ) {
  769.                             term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  770.                             if ( term==NULL && UserDefdTokens ) {
  771.                                 err("implicit token definition not allowed with #tokdefs");
  772.                                 go = 0;
  773.                             }
  774.                             else {t=mystrdup(LATEXT(1)); tok=addTexpr(LATEXT(1));}
  775.                         }  
  776.  zzCONSUME;
  777.                     }
  778.                     else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  779.                 }
  780.                 zzEXIT(zztasp3);
  781.                 }
  782.             }
  783.             if ( go ) list_add(&(e->tlist), t);  
  784.             zzLOOP(zztasp2);
  785.         }
  786.         zzEXIT(zztasp2);
  787.         }
  788.     }
  789.     zzmatch(86); zzCONSUME;
  790.     zzEXIT(zztasp1);
  791.     return;
  792. fail:
  793.     zzEXIT(zztasp1);
  794.     CannotContinue=TRUE;  
  795.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  796.     zzresynch(setwd2, 0x2);
  797.     }
  798. }
  799.  
  800. void
  801. #ifdef __STDC__
  802. token(void)
  803. #else
  804. token()
  805. #endif
  806. {
  807.     zzRULE;
  808.     zzBLOCK(zztasp1);
  809.     zzMake0;
  810.     {
  811.     char *t=NULL, *e=NULL, *a=NULL; int tnum=0;  
  812.     zzmatch(100); zzCONSUME;
  813.     {
  814.         zzBLOCK(zztasp2);
  815.         zzMake0;
  816.         {
  817.         if ( (LA(1)==TokenTerm) ) {
  818.             zzmatch(TokenTerm);
  819.             t=mystrdup(LATEXT(1));  
  820.  zzCONSUME;
  821.             {
  822.                 zzBLOCK(zztasp3);
  823.                 zzMake0;
  824.                 {
  825.                 if ( (LA(1)==101) ) {
  826.                     zzmatch(101); zzCONSUME;
  827.                     zzmatch(102);
  828.                     tnum = atoi(LATEXT(1));  
  829.  zzCONSUME;
  830.                 }
  831.                 zzEXIT(zztasp3);
  832.                 }
  833.             }
  834.         }
  835.         zzEXIT(zztasp2);
  836.         }
  837.     }
  838.     {
  839.         zzBLOCK(zztasp2);
  840.         zzMake0;
  841.         {
  842.         if ( (LA(1)==QuotedTerm) ) {
  843.             zzmatch(QuotedTerm);
  844.             e=mystrdup(LATEXT(1));  
  845.  zzCONSUME;
  846.         }
  847.         zzEXIT(zztasp2);
  848.         }
  849.     }
  850.     {
  851.         zzBLOCK(zztasp2);
  852.         zzMake0;
  853.         {
  854.         if ( (LA(1)==Action) ) {
  855.             zzmatch(Action);
  856.             
  857.             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  858.             require(a!=NULL, "rule token: cannot allocate action");
  859.             strcpy(a, LATEXT(1));
  860.  zzCONSUME;
  861.         }
  862.         zzEXIT(zztasp2);
  863.         }
  864.     }
  865.     chkToken(t, e, a, tnum);  
  866.     zzEXIT(zztasp1);
  867.     return;
  868. fail:
  869.     zzEXIT(zztasp1);
  870.     CannotContinue=TRUE;  
  871.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  872.     zzresynch(setwd2, 0x4);
  873.     }
  874. }
  875.  
  876. void
  877. #ifdef __STDC__
  878. block( set *toksrefd, set *rulesrefd )
  879. #else
  880. block(toksrefd,rulesrefd)
  881.  set *toksrefd;
  882. set *rulesrefd ;
  883. #endif
  884. {
  885.     zzRULE;
  886.     zzBLOCK(zztasp1);
  887.     zzMake0;
  888.     {
  889.     
  890.     Graph g, b;
  891.     * toksrefd = empty;
  892.     * rulesrefd = empty;
  893.     set_clr(AST_nodes_refd_in_actions);
  894.     alt( toksrefd,rulesrefd );
  895.     b = g = zzaArg(zztasp1,1);  
  896.     
  897.     if ( ((Junction *)g.left)->p1->ntype == nAction )
  898.     {
  899.         if ( !((ActionNode *)(((Junction *)g.left)->p1))->is_predicate )
  900.         {
  901.             ((ActionNode *)(((Junction *)g.left)->p1))->init_action = TRUE;
  902.         }
  903.     }
  904.     {
  905.         zzBLOCK(zztasp2);
  906.         zzMake0;
  907.         {
  908.         while ( (LA(1)==103) ) {
  909.             zzmatch(103); zzCONSUME;
  910.             alt( toksrefd,rulesrefd );
  911.             g = Or(g, zzaArg(zztasp2,2));  
  912.             zzLOOP(zztasp2);
  913.         }
  914.         zzEXIT(zztasp2);
  915.         }
  916.     }
  917.     zzaArg(zztasp1,0) = b;  
  918.     zzEXIT(zztasp1);
  919.     return;
  920. fail:
  921.     zzEXIT(zztasp1);
  922.     CannotContinue=TRUE;  
  923.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  924.     zzresynch(setwd2, 0x8);
  925.     }
  926. }
  927.  
  928. void
  929. #ifdef __STDC__
  930. alt( set *toksrefd, set *rulesrefd )
  931. #else
  932. alt(toksrefd,rulesrefd)
  933.  set *toksrefd;
  934. set *rulesrefd ;
  935. #endif
  936. {
  937.     zzRULE;
  938.     zzBLOCK(zztasp1);
  939.     zzMake0;
  940.     {
  941.     int n=0,ne=0; Graph g; int e_num=0, not=0;
  942.     int first_on_line = 1;
  943.     g.left=NULL; g.right=NULL;
  944.     {
  945.         zzBLOCK(zztasp2);
  946.         zzMake0;
  947.         {
  948.         int tok;  
  949.         while ( (setwd2[LA(1)]&0x10) ) {
  950.             tok = LA(1);  
  951.             {
  952.                 zzBLOCK(zztasp3);
  953.                 zzMake0;
  954.                 {
  955.                 not=0;  
  956.                 if ( (LA(1)==104) ) {
  957.                     zzmatch(104);
  958.                     not=1;  
  959.  zzCONSUME;
  960.                 }
  961.                 zzEXIT(zztasp3);
  962.                 }
  963.             }
  964.             element( not, first_on_line );
  965.             if ( tok!=Action && tok!=Pred ) first_on_line = 0;  
  966.             
  967.             if ( zzaArg(zztasp2,2 ).left!=NULL ) {
  968.                 g = Cat(g, zzaArg(zztasp2,2));
  969.                 n++;
  970.                 if ( tok!=Action && tok!=Pred ) e_num++;
  971.                 /* record record number of all rule and token refs */
  972.                 if ( tok==TokenTerm||tok==QuotedTerm||tok==WildCard ) {
  973.                     ((TokNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1)->elnum = e_num;
  974.                     set_orel(e_num,  toksrefd);
  975.                 }
  976.                 else if ( tok==NonTerminal ) {
  977.                     ((RuleRefNode *)((Junction *)zzaArg(zztasp2,2 ).left)->p1)->elnum = e_num;
  978.                     set_orel(e_num,  rulesrefd);
  979.                 }
  980.             }
  981.             zzLOOP(zztasp2);
  982.         }
  983.         zzEXIT(zztasp2);
  984.         }
  985.     }
  986.     if ( n == 0 ) g = emptyAlt();
  987.     zzaArg(zztasp1,0) = g;
  988.     zzEXIT(zztasp1);
  989.     return;
  990. fail:
  991.     zzEXIT(zztasp1);
  992.     CannotContinue=TRUE;  
  993.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  994.     zzresynch(setwd2, 0x20);
  995.     }
  996. }
  997.  
  998. void
  999. #ifdef __STDC__
  1000. element( int not, int first_on_line )
  1001. #else
  1002. element(not,first_on_line)
  1003.  int not;
  1004. int first_on_line ;
  1005. #endif
  1006. {
  1007.     zzRULE;
  1008.     zzBLOCK(zztasp1);
  1009.     zzMake0;
  1010.     {
  1011.     
  1012.     set toksrefd, rulesrefd;
  1013.     TermEntry *term;
  1014.     TokNode *p=NULL; RuleRefNode *q; int approx=0;
  1015.     if ( (LA(1)==TokenTerm) ) {
  1016.         zzmatch(TokenTerm);
  1017.         
  1018.         term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1019.         if ( term==NULL && UserDefdTokens ) {
  1020.             err("implicit token definition not allowed with #tokdefs");
  1021.             zzaArg(zztasp1,0 ).left = zzaArg(zztasp1,0 ).right = NULL;
  1022.         }
  1023.         else {
  1024.             zzaArg(zztasp1,0) = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)zzaArg(zztasp1,0 ).left)->p1);
  1025.             term = (TermEntry *) hash_get(Tname, LATEXT(1));
  1026.             require( term!= NULL, "hash table mechanism is broken");
  1027.             p->tclass = term->tclass;
  1028.             p->complement =  not;
  1029.         }
  1030.  zzCONSUME;
  1031.         {
  1032.             zzBLOCK(zztasp2);
  1033.             zzMake0;
  1034.             {
  1035.             if ( (LA(1)==105) ) {
  1036.                 zzmatch(105); zzCONSUME;
  1037.                 {
  1038.                     zzBLOCK(zztasp3);
  1039.                     zzMake0;
  1040.                     {
  1041.                     if ( (LA(1)==QuotedTerm) ) {
  1042.                         zzmatch(QuotedTerm);
  1043.                         if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1044.  zzCONSUME;
  1045.                     }
  1046.                     else {
  1047.                         if ( (LA(1)==TokenTerm) ) {
  1048.                             zzmatch(TokenTerm);
  1049.                             if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1050.  zzCONSUME;
  1051.                         }
  1052.                         else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1053.                     }
  1054.                     zzEXIT(zztasp3);
  1055.                     }
  1056.                 }
  1057.             }
  1058.             zzEXIT(zztasp2);
  1059.             }
  1060.         }
  1061.         
  1062.         if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  1063.         list_add(&MetaTokenNodes, (void *)p);
  1064.         {
  1065.             zzBLOCK(zztasp2);
  1066.             zzMake0;
  1067.             {
  1068.             if ( (LA(1)==106) ) {
  1069.                 zzmatch(106);
  1070.                 if ( p!=NULL ) p->astnode=ASTroot;  
  1071.  zzCONSUME;
  1072.             }
  1073.             else {
  1074.                 if ( (setwd2[LA(1)]&0x40) ) {
  1075.                     if ( p!=NULL ) p->astnode=ASTchild;  
  1076.                 }
  1077.                 else {
  1078.                     if ( (LA(1)==91) ) {
  1079.                         zzmatch(91);
  1080.                         if ( p!=NULL ) p->astnode=ASTexclude;  
  1081.  zzCONSUME;
  1082.                     }
  1083.                     else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1084.                 }
  1085.             }
  1086.             zzEXIT(zztasp2);
  1087.             }
  1088.         }
  1089.     }
  1090.     else {
  1091.         if ( (LA(1)==QuotedTerm) ) {
  1092.             zzmatch(QuotedTerm);
  1093.             
  1094.             term = (TermEntry *) hash_get(Texpr, LATEXT(1));
  1095.             if ( term==NULL && UserDefdTokens ) {
  1096.                 err("implicit token definition not allowed with #tokdefs");
  1097.                 zzaArg(zztasp1,0 ).left = zzaArg(zztasp1,0 ).right = NULL;
  1098.             }
  1099.             else {
  1100.                 zzaArg(zztasp1,0) = buildToken(LATEXT(1)); p=((TokNode *)((Junction *)zzaArg(zztasp1,0 ).left)->p1);
  1101.                 p->complement =  not;
  1102.             }
  1103.  zzCONSUME;
  1104.             {
  1105.                 zzBLOCK(zztasp2);
  1106.                 zzMake0;
  1107.                 {
  1108.                 if ( (LA(1)==105) ) {
  1109.                     zzmatch(105); zzCONSUME;
  1110.                     {
  1111.                         zzBLOCK(zztasp3);
  1112.                         zzMake0;
  1113.                         {
  1114.                         if ( (LA(1)==QuotedTerm) ) {
  1115.                             zzmatch(QuotedTerm);
  1116.                             if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1117.  zzCONSUME;
  1118.                         }
  1119.                         else {
  1120.                             if ( (LA(1)==TokenTerm) ) {
  1121.                                 zzmatch(TokenTerm);
  1122.                                 if ( p!=NULL ) setUpperRange(p, LATEXT(1));  
  1123.  zzCONSUME;
  1124.                             }
  1125.                             else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1126.                         }
  1127.                         zzEXIT(zztasp3);
  1128.                         }
  1129.                     }
  1130.                 }
  1131.                 zzEXIT(zztasp2);
  1132.                 }
  1133.             }
  1134.             {
  1135.                 zzBLOCK(zztasp2);
  1136.                 zzMake0;
  1137.                 {
  1138.                 if ( (LA(1)==106) ) {
  1139.                     zzmatch(106);
  1140.                     if ( p!=NULL ) p->astnode=ASTroot;  
  1141.  zzCONSUME;
  1142.                 }
  1143.                 else {
  1144.                     if ( (setwd2[LA(1)]&0x80) ) {
  1145.                         if ( p!=NULL ) p->astnode=ASTchild;  
  1146.                     }
  1147.                     else {
  1148.                         if ( (LA(1)==91) ) {
  1149.                             zzmatch(91);
  1150.                             if ( p!=NULL ) p->astnode=ASTexclude;  
  1151.  zzCONSUME;
  1152.                         }
  1153.                         else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1154.                     }
  1155.                 }
  1156.                 zzEXIT(zztasp2);
  1157.                 }
  1158.             }
  1159.             
  1160.             if ( p!=NULL && (p->upper_range!=0 || p->tclass ||  not) )
  1161.             list_add(&MetaTokenNodes, (void *)p);
  1162.         }
  1163.         else {
  1164.             if ( (LA(1)==WildCard) ) {
  1165.                 if (  not ) warn("~ WILDCARD is an undefined operation (implies 'nothing')");  
  1166.                 zzmatch(WildCard);
  1167.                 zzaArg(zztasp1,0) = buildWildCard(LATEXT(1)); p=((TokNode *)((Junction *)zzaArg(zztasp1,0 ).left)->p1);  
  1168.  zzCONSUME;
  1169.                 {
  1170.                     zzBLOCK(zztasp2);
  1171.                     zzMake0;
  1172.                     {
  1173.                     if ( (LA(1)==106) ) {
  1174.                         zzmatch(106);
  1175.                         p->astnode=ASTroot;  
  1176.  zzCONSUME;
  1177.                     }
  1178.                     else {
  1179.                         if ( (setwd3[LA(1)]&0x1) ) {
  1180.                             p->astnode=ASTchild;  
  1181.                         }
  1182.                         else {
  1183.                             if ( (LA(1)==91) ) {
  1184.                                 zzmatch(91);
  1185.                                 p->astnode=ASTexclude;  
  1186.  zzCONSUME;
  1187.                             }
  1188.                             else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1189.                         }
  1190.                     }
  1191.                     zzEXIT(zztasp2);
  1192.                     }
  1193.                 }
  1194.                 list_add(&MetaTokenNodes, (void *)p);  
  1195.             }
  1196.             else {
  1197.                 if ( (LA(1)==NonTerminal) ) {
  1198.                     if (  not ) warn("~ NONTERMINAL is an undefined operation");  
  1199.                     zzmatch(NonTerminal);
  1200.                     zzaArg(zztasp1,0) = buildRuleRef(LATEXT(1));  
  1201.  zzCONSUME;
  1202.                     {
  1203.                         zzBLOCK(zztasp2);
  1204.                         zzMake0;
  1205.                         {
  1206.                         if ( (LA(1)==91) ) {
  1207.                             zzmatch(91);
  1208.                             q = (RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  1209.                             q->astnode=ASTexclude;  
  1210.  zzCONSUME;
  1211.                         }
  1212.                         zzEXIT(zztasp2);
  1213.                         }
  1214.                     }
  1215.                     {
  1216.                         zzBLOCK(zztasp2);
  1217.                         zzMake0;
  1218.                         {
  1219.                         if ( (setwd3[LA(1)]&0x2) ) {
  1220.                             {
  1221.                                 zzBLOCK(zztasp3);
  1222.                                 zzMake0;
  1223.                                 {
  1224.                                 if ( (LA(1)==92) ) {
  1225.                                     zzmatch(92); zzCONSUME;
  1226.                                 }
  1227.                                 zzEXIT(zztasp3);
  1228.                                 }
  1229.                             }
  1230.                             zzmatch(PassAction);
  1231.                             addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  1232.  zzCONSUME;
  1233.                         }
  1234.                         zzEXIT(zztasp2);
  1235.                         }
  1236.                     }
  1237.                     {
  1238.                         zzBLOCK(zztasp2);
  1239.                         zzMake0;
  1240.                         {
  1241.                         char *a; RuleRefNode *rr=(RuleRefNode *) ((Junction *)zzaRet.left)->p1;
  1242.                         if ( (LA(1)==93) ) {
  1243.                             zzmatch(93); zzCONSUME;
  1244.                             zzmatch(PassAction);
  1245.                             
  1246.                             a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1247.                             require(a!=NULL, "rule element: cannot allocate assignment");
  1248.                             strcpy(a, LATEXT(1));
  1249.                             rr->assign = a;
  1250.  zzCONSUME;
  1251.                         }
  1252.                         zzEXIT(zztasp2);
  1253.                         }
  1254.                     }
  1255.                 }
  1256.                 else {
  1257.                     if ( (LA(1)==Action) ) {
  1258.                         if (  not )    warn("~ ACTION is an undefined operation");  
  1259.                         zzmatch(Action);
  1260.                         zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 0);  
  1261.  zzCONSUME;
  1262.                     }
  1263.                     else {
  1264.                         if ( (LA(1)==Pred) ) {
  1265.                             if (  not )    warn("~ SEMANTIC-PREDICATE is an undefined operation");  
  1266.                             zzmatch(Pred);
  1267.                             zzaArg(zztasp1,0) = buildAction(LATEXT(1),action_file,action_line, 1);  
  1268.  zzCONSUME;
  1269.                             {
  1270.                                 zzBLOCK(zztasp2);
  1271.                                 zzMake0;
  1272.                                 {
  1273.                                 char *a; ActionNode *act = (ActionNode *) ((Junction *)zzaRet.left)->p1;  
  1274.                                 if ( (LA(1)==PassAction) ) {
  1275.                                     zzmatch(PassAction);
  1276.                                     
  1277.                                     a = (char *) calloc(strlen(LATEXT(1))+1, sizeof(char));
  1278.                                     require(a!=NULL, "rule element: cannot allocate predicate fail action");
  1279.                                     strcpy(a, LATEXT(1));
  1280.                                     act->pred_fail = a;
  1281.  zzCONSUME;
  1282.                                 }
  1283.                                 zzEXIT(zztasp2);
  1284.                                 }
  1285.                             }
  1286.                         }
  1287.                         else {
  1288.                             if ( (setwd3[LA(1)]&0x4) ) {
  1289.                                 if (  not )    warn("~ BLOCK is an undefined operation");  
  1290.                                 BlkLevel++;  
  1291.                                 {
  1292.                                     zzBLOCK(zztasp2);
  1293.                                     zzMake0;
  1294.                                     {
  1295.                                     if ( (LA(1)==107) ) {
  1296.                                         zzmatch(107); zzCONSUME;
  1297.                                         {
  1298.                                             zzBLOCK(zztasp3);
  1299.                                             zzMake0;
  1300.                                             {
  1301.                                             if ( (LA(1)==108) ) {
  1302.                                                 zzmatch(108);
  1303.                                                 approx=LL_k;  
  1304.  zzCONSUME;
  1305.                                             }
  1306.                                             else {
  1307.                                                 if ( (LA(1)==109) ) {
  1308.                                                     zzmatch(109);
  1309.                                                     approx = 1;  
  1310.  zzCONSUME;
  1311.                                                 }
  1312.                                                 else {
  1313.                                                     if ( (LA(1)==110) ) {
  1314.                                                         zzmatch(110);
  1315.                                                         approx = 2;  
  1316.  zzCONSUME;
  1317.                                                     }
  1318.                                                     else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1319.                                                 }
  1320.                                             }
  1321.                                             zzEXIT(zztasp3);
  1322.                                             }
  1323.                                         }
  1324.                                     }
  1325.                                     zzEXIT(zztasp2);
  1326.                                     }
  1327.                                 }
  1328.                                 {
  1329.                                     zzBLOCK(zztasp2);
  1330.                                     zzMake0;
  1331.                                     {
  1332.                                     if ( (LA(1)==111) ) {
  1333.                                         zzmatch(111); zzCONSUME;
  1334.                                         block( &toksrefd,&rulesrefd );
  1335.                                         zzaRet = zzaArg(zztasp2,2); --BlkLevel;  
  1336.                                         zzmatch(112); zzCONSUME;
  1337.                                         {
  1338.                                             zzBLOCK(zztasp3);
  1339.                                             zzMake0;
  1340.                                             {
  1341.                                             if ( (LA(1)==113) ) {
  1342.                                                 zzmatch(113);
  1343.                                                 zzaRet = makeLoop(zzaRet,approx);  
  1344.  zzCONSUME;
  1345.                                             }
  1346.                                             else {
  1347.                                                 if ( (LA(1)==114) ) {
  1348.                                                     zzmatch(114);
  1349.                                                     zzaRet = makePlus(zzaRet,approx);  
  1350.  zzCONSUME;
  1351.                                                 }
  1352.                                                 else {
  1353.                                                     if ( (LA(1)==115) ) {
  1354.                                                         zzmatch(115);
  1355.                                                         zzaRet = makeBlk(zzaRet,approx);
  1356.                                                         FoundGuessBlk = 1;
  1357.                                                         ((Junction *) ((Junction *)zzaRet.left)->p1)->guess=1;
  1358.                                                         if ( ! first_on_line ) {
  1359.                                                             err("(...)? predicate must be first element of production");
  1360.                                                         }
  1361.  zzCONSUME;
  1362.                                                     }
  1363.                                                     else {
  1364.                                                         if ( (setwd3[LA(1)]&0x8) ) {
  1365.                                                             zzaRet = makeBlk(zzaRet,approx);  
  1366.                                                         }
  1367.                                                         else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1368.                                                     }
  1369.                                                 }
  1370.                                             }
  1371.                                             zzEXIT(zztasp3);
  1372.                                             }
  1373.                                         }
  1374.                                         
  1375.                                         ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  1376.                                         ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  1377.                                         {
  1378.                                             zzBLOCK(zztasp3);
  1379.                                             zzMake0;
  1380.                                             {
  1381.                                             if ( (LA(1)==PassAction) ) {
  1382.                                                 zzmatch(PassAction);
  1383.                                                 addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  1384.  zzCONSUME;
  1385.                                             }
  1386.                                             zzEXIT(zztasp3);
  1387.                                             }
  1388.                                         }
  1389.                                     }
  1390.                                     else {
  1391.                                         if ( (LA(1)==90) ) {
  1392.                                             zzmatch(90); zzCONSUME;
  1393.                                             block( &toksrefd,&rulesrefd );
  1394.                                             zzaRet = makeOpt(zzaArg(zztasp2,2),approx); --BlkLevel;  
  1395.                                             zzmatch(86);
  1396.                                             
  1397.                                             ((Junction *)((Junction *)zzaRet.left)->p1)->tokrefs = toksrefd;
  1398.                                             ((Junction *)((Junction *)zzaRet.left)->p1)->rulerefs = rulesrefd;
  1399.  zzCONSUME;
  1400.                                             {
  1401.                                                 zzBLOCK(zztasp3);
  1402.                                                 zzMake0;
  1403.                                                 {
  1404.                                                 if ( (LA(1)==PassAction) ) {
  1405.                                                     zzmatch(PassAction);
  1406.                                                     addParm(((Junction *)zzaRet.left)->p1, LATEXT(1));  
  1407.  zzCONSUME;
  1408.                                                 }
  1409.                                                 zzEXIT(zztasp3);
  1410.                                                 }
  1411.                                             }
  1412.                                         }
  1413.                                         else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1414.                                     }
  1415.                                     zzEXIT(zztasp2);
  1416.                                     }
  1417.                                 }
  1418.                             }
  1419.                             else {
  1420.                                 if ( (LA(1)==94) ) {
  1421.                                     zzmatch(94);
  1422.                                     warn(eMsg1("missing ';' on rule %s", CurRule));
  1423.                                     CannotContinue=TRUE;  
  1424.  zzCONSUME;
  1425.                                 }
  1426.                                 else {
  1427.                                     if ( (LA(1)==113) ) {
  1428.                                         zzmatch(113);
  1429.                                         warn("don't you want a ')' with that '*'?"); CannotContinue=TRUE;  
  1430.  zzCONSUME;
  1431.                                     }
  1432.                                     else {
  1433.                                         if ( (LA(1)==114) ) {
  1434.                                             zzmatch(114);
  1435.                                             warn("don't you want a ')' with that '+'?"); CannotContinue=TRUE;  
  1436.  zzCONSUME;
  1437.                                         }
  1438.                                         else {
  1439.                                             if ( (LA(1)==93) ) {
  1440.                                                 zzmatch(93);
  1441.                                                 warn("'>' can only appear after a nonterminal"); CannotContinue=TRUE;  
  1442.  zzCONSUME;
  1443.                                             }
  1444.                                             else {
  1445.                                                 if ( (LA(1)==PassAction) ) {
  1446.                                                     zzmatch(PassAction);
  1447.                                                     warn("[...] out of context 'rule > [...]'");
  1448.                                                     CannotContinue=TRUE;  
  1449.  zzCONSUME;
  1450.                                                 }
  1451.                                                 else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1452.                                             }
  1453.                                         }
  1454.                                     }
  1455.                                 }
  1456.                             }
  1457.                         }
  1458.                     }
  1459.                 }
  1460.             }
  1461.         }
  1462.     }
  1463.     zzEXIT(zztasp1);
  1464.     return;
  1465. fail:
  1466.     zzEXIT(zztasp1);
  1467.     CannotContinue=TRUE;  
  1468.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1469.     zzresynch(setwd3, 0x10);
  1470.     }
  1471. }
  1472.  
  1473. void
  1474. #ifdef __STDC__
  1475. enum_file( char *fname )
  1476. #else
  1477. enum_file(fname)
  1478.  char *fname ;
  1479. #endif
  1480. {
  1481.     zzRULE;
  1482.     zzBLOCK(zztasp1);
  1483.     zzMake0;
  1484.     {
  1485.     if ( (setwd3[LA(1)]&0x20) ) {
  1486.         {
  1487.             zzBLOCK(zztasp2);
  1488.             zzMake0;
  1489.             {
  1490.             while ( (LA(1)==124) ) {
  1491.                 enum_def(  fname );
  1492.                 zzLOOP(zztasp2);
  1493.             }
  1494.             zzEXIT(zztasp2);
  1495.             }
  1496.         }
  1497.     }
  1498.     else {
  1499.         if ( (setwd3[LA(1)]&0x40) ) {
  1500.             defines(  fname );
  1501.         }
  1502.         else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1503.     }
  1504.     zzEXIT(zztasp1);
  1505.     return;
  1506. fail:
  1507.     zzEXIT(zztasp1);
  1508.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1509.     zzresynch(setwd3, 0x80);
  1510.     }
  1511. }
  1512.  
  1513. void
  1514. #ifdef __STDC__
  1515. defines( char *fname )
  1516. #else
  1517. defines(fname)
  1518.  char *fname ;
  1519. #endif
  1520. {
  1521.     zzRULE;
  1522.     zzBLOCK(zztasp1);
  1523.     zzMake0;
  1524.     {
  1525.     int v,maxt= -1; char *t;  
  1526.     {
  1527.         zzBLOCK(zztasp2);
  1528.         zzMake0;
  1529.         {
  1530.         while ( (LA(1)==121) ) {
  1531.             zzmatch(121); zzCONSUME;
  1532.             zzmatch(ID);
  1533.             t = mystrdup(LATEXT(1));  
  1534.  zzCONSUME;
  1535.             zzmatch(INT);
  1536.             
  1537.             v = atoi(LATEXT(1));
  1538.             /*            fprintf(stderr, "#token %s=%d\n", t, v); */
  1539.             TokenNum = v;
  1540.             if ( v>maxt ) maxt=v;
  1541.             if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  1542.             else {
  1543.                 warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  1544.             }
  1545.  zzCONSUME;
  1546.             zzLOOP(zztasp2);
  1547.         }
  1548.         zzEXIT(zztasp2);
  1549.         }
  1550.     }
  1551.     TokenNum = maxt + 1;  
  1552.     zzEXIT(zztasp1);
  1553.     return;
  1554. fail:
  1555.     zzEXIT(zztasp1);
  1556.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1557.     zzresynch(setwd4, 0x1);
  1558.     }
  1559. }
  1560.  
  1561. void
  1562. #ifdef __STDC__
  1563. enum_def( char *fname )
  1564. #else
  1565. enum_def(fname)
  1566.  char *fname ;
  1567. #endif
  1568. {
  1569.     zzRULE;
  1570.     zzBLOCK(zztasp1);
  1571.     zzMake0;
  1572.     {
  1573.     int v= -1; char *t;  
  1574.     zzmatch(124); zzCONSUME;
  1575.     zzmatch(ID); zzCONSUME;
  1576.     zzmatch(125); zzCONSUME;
  1577.     zzmatch(ID);
  1578.     t = mystrdup(LATEXT(1));  
  1579.  zzCONSUME;
  1580.     {
  1581.         zzBLOCK(zztasp2);
  1582.         zzMake0;
  1583.         {
  1584.         if ( (LA(1)==126) ) {
  1585.             zzmatch(126); zzCONSUME;
  1586.             zzmatch(INT);
  1587.             v=atoi(LATEXT(1));  
  1588.  zzCONSUME;
  1589.         }
  1590.         else {
  1591.             if ( (setwd4[LA(1)]&0x2) ) {
  1592.                 v++;  
  1593.             }
  1594.             else {zzFAIL(1,zzerr16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1595.         }
  1596.         zzEXIT(zztasp2);
  1597.         }
  1598.     }
  1599.     
  1600.     /*            fprintf(stderr, "#token %s=%d\n", t, v);*/
  1601.     TokenNum = v;
  1602.     if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  1603.     else {
  1604.         warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  1605.     }
  1606.     {
  1607.         zzBLOCK(zztasp2);
  1608.         zzMake0;
  1609.         {
  1610.         while ( (LA(1)==127) ) {
  1611.             zzmatch(127); zzCONSUME;
  1612.             {
  1613.                 zzBLOCK(zztasp3);
  1614.                 zzMake0;
  1615.                 {
  1616.                 if ( (LA(1)==ID) ) {
  1617.                     zzmatch(ID);
  1618.                     t = mystrdup(LATEXT(1));  
  1619.  zzCONSUME;
  1620.                     {
  1621.                         zzBLOCK(zztasp4);
  1622.                         zzMake0;
  1623.                         {
  1624.                         if ( (LA(1)==126) ) {
  1625.                             zzmatch(126); zzCONSUME;
  1626.                             zzmatch(INT);
  1627.                             v=atoi(LATEXT(1));  
  1628.  zzCONSUME;
  1629.                         }
  1630.                         else {
  1631.                             if ( (setwd4[LA(1)]&0x4) ) {
  1632.                                 v++;  
  1633.                             }
  1634.                             else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  1635.                         }
  1636.                         zzEXIT(zztasp4);
  1637.                         }
  1638.                     }
  1639.                     
  1640.                     /*                    fprintf(stderr, "#token %s=%d\n", t, v);*/
  1641.                     TokenNum = v;
  1642.                     if ( Tnum( t ) == 0 ) addForcedTname( t, v );
  1643.                     else {
  1644.                         warnFL(eMsg1("redefinition of token %s; ignored",t), fname,zzline);
  1645.                     }
  1646.                 }
  1647.                 zzEXIT(zztasp3);
  1648.                 }
  1649.             }
  1650.             zzLOOP(zztasp2);
  1651.         }
  1652.         zzEXIT(zztasp2);
  1653.         }
  1654.     }
  1655.     zzmatch(128); zzCONSUME;
  1656.     zzmatch(129);
  1657.     TokenNum++;  
  1658.  zzCONSUME;
  1659.     zzEXIT(zztasp1);
  1660.     return;
  1661. fail:
  1662.     zzEXIT(zztasp1);
  1663.     zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  1664.     zzresynch(setwd4, 0x8);
  1665.     }
  1666. }
  1667.  
  1668. /* semantics of #token */
  1669. static void
  1670. #ifdef __STDC__
  1671. chkToken(char *t, char *e, char *a, int tnum)
  1672. #else
  1673. chkToken(t,e,a,tnum)
  1674. char *t, *e, *a;
  1675. int tnum;
  1676. #endif
  1677. {
  1678.     TermEntry *p;
  1679.     
  1680.     /* check to see that they don't try to redefine a token as a token class */
  1681.     if ( t!=NULL ) {
  1682.     p = (TermEntry *) hash_get(Tname, t);
  1683.     if ( p!=NULL && p->classname ) {
  1684.     err(eMsg1("redefinition of #tokclass '%s' to #token not allowed; ignored",t));
  1685.     if ( a!=NULL ) free((char *)a);
  1686.     return;
  1687. }
  1688. }
  1689.  
  1690.     if ( t==NULL && e==NULL ) {            /* none found */
  1691. err("#token requires at least token name or rexpr");
  1692. }
  1693. else if ( t!=NULL && e!=NULL ) {    /* both found */
  1694. if ( UserDefdTokens ) {            /* if #tokdefs, must not define new */
  1695. p = (TermEntry *) hash_get(Tname, t);
  1696. if ( p==NULL ) {
  1697. err(eMsg1("#token definition '%s' not allowed with #tokdefs; ignored",t));
  1698. return;
  1699. }
  1700. }
  1701. Tklink(t, e);
  1702. if ( a!=NULL ) {
  1703. if ( hasAction(e) ) {
  1704. err(eMsg1("redefinition of action for %s; ignored",e));
  1705. }
  1706. else setHasAction(e, a);
  1707. }
  1708. }
  1709. else if ( t!=NULL ) {                /* only one found */
  1710. if ( UserDefdTokens ) {
  1711. err(eMsg1("#token definition '%s' not allowed with #tokdefs; ignored",t));
  1712. return;
  1713. }
  1714. if ( Tnum( t ) == 0 ) addTname( t );
  1715. else {
  1716. err(eMsg1("redefinition of token %s; ignored",t));
  1717. }
  1718. if ( a!=NULL ) {
  1719. err(eMsg1("action cannot be attached to a token name (%s); ignored",t));
  1720. free((char *)a);
  1721. }
  1722. }
  1723. else if ( e!=NULL ) {
  1724. if ( Tnum( e ) == 0 ) addTexpr( e );
  1725. else {
  1726. if ( hasAction(e) ) {
  1727. err(eMsg1("redefinition of action for expr %s; ignored",e));
  1728. }
  1729. else if ( a==NULL ) {
  1730. err(eMsg1("redefinition of expr %s; ignored",e));
  1731. }
  1732. }
  1733. if ( a!=NULL ) setHasAction(e, a);
  1734. }
  1735.  
  1736.     /* if a token type number was specified, then add the token ID and 'tnum'
  1737. * pair to the ForcedTokens list.  (only applies if an id was given)
  1738. */
  1739. if ( t!=NULL && tnum>0 )
  1740. {
  1741. if ( set_el(tnum, reserved_positions) )
  1742. {
  1743. err(eMsgd("a token has already been forced to token number %d; ignored", tnum));
  1744. }
  1745. else
  1746. {
  1747. list_add(&ForcedTokens, newForcedToken(t,tnum));
  1748. set_orel(tnum, &reserved_positions);
  1749. }
  1750. }
  1751. }
  1752.  
  1753. /* ANTLR-specific syntax error message generator 
  1754. * (define USER_ZZSYN when compiling so don't get 2 definitions)
  1755. */
  1756. void
  1757. #ifdef __STDC__
  1758. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
  1759. #else
  1760. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  1761. char *text, *egroup, *bad_text;
  1762. int tok;
  1763. int etok;
  1764. int k;
  1765. SetWordType *eset;
  1766. #endif
  1767. {
  1768. fprintf(stderr, ErrHdr, FileStr[CurFile]!=NULL?FileStr[CurFile]:"stdin", zzline);
  1769. fprintf(stderr, " syntax error at \"%s\"", (tok==zzEOF_TOKEN)?"EOF":text);
  1770. if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
  1771. if ( k==1 ) fprintf(stderr, " missing");
  1772. else
  1773. {
  1774. fprintf(stderr, "; \"%s\" not", bad_text);
  1775. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  1776. }
  1777. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  1778. else fprintf(stderr, " %s", zztokens[etok]);
  1779. if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
  1780. fprintf(stderr, "\n");
  1781. }
  1782.